class Wynik {
       
        // Sortowanie kart jakie otrzymuje gracz
        public static Card[] sortCards (Card[] karty) {
               
                int countSort;
                int[] bufor = new int[2];
               
                do {
                        //System.out.println(karty.length+" "+talia[0].length);
                        countSort = 0;
                        for (int i=0; i<karty.length-1;i++){
                                if (karty[i].card[0] > karty[i+1].card[0]){
                                        //System.out.println(talia[i+1][0]+" ");
                                        countSort++;
                                        bufor[0] = karty[i].card[0];
                                        bufor[1] = karty[i].card[1];
                                       
                                        karty[i].card[0] = karty[i+1].card[0];
                                        karty[i].card[1] = karty[i+1].card[1];
                                       
                                        karty[i+1].card[0] = bufor[0];
                                        karty[i+1].card[1] = bufor[1];

                                }
                        }
                       
                } while(countSort != 0);
                //for (int i=0;i<5;i++){
                //      System.out.println(talia[i][0]+"\t");
                //}
                //System.out.println("\n");
                return karty;
        }
       
        // Poker :  Piec kolejnych kart w jednym kolorze. Gdy wiecej graczy posiada
        // taki uklad, wygrywa uklad z najwyzsza karta. Jesli najwyzsza karta jest taka sama oglaszamy
        // remis.
        //
        // Metoda zwraca najwyzsza karte jezeli jest poker, w przeciwnym wypadku zwraca 0.
        //
        public static int poker(Card[] karty){
                int wynik = 0;
                boolean chck = true;
                for (int i=0; i<karty.length-1;i++){
                        //System.out.println(karty[i].card[0]+"\t"+karty[i+1].card[0]+" "+"-2-");
                        //System.out.println(karty[i].card[1]+"\t"+karty[i+1].card[1]+" "+"-1-");
                       
                        if (karty[i].card[1] != karty[i+1].card[1] || karty[i].card[0]+1 != karty[i+1].card[0]){
                                chck = false;
                                //System.out.println("lol"+"\n");
                                break;
                        }

                        //System.out.println(
                }
                if (chck) {
                        wynik = karty[4].card[0];
                }
                return wynik;
        }
       
        // Kareta : Cztery karty o jednakowej wartosci Gdy wiecej graczy posiada taki uklad wygrywa najwyzsza czw�rka.
        //
        // Metoda zwraca najwyzsza karte jezeli jest kareta, w przeciwnym wypadku zwraca 0.
        //
        public static int kareta(Card[] karty){
                int chck = 0;
                int najwyzszaKarta = 0;
                for (int i=0; i<karty.length-1;i++){
                        if(karty[i].card[0] == karty[i+1].card[0]){
                               
                                chck++;
                                najwyzszaKarta = karty[i].card[0];
                                continue;
                        }
                        break;
                }
                if (chck == 3){
                        return najwyzszaKarta;
                } else { return 0; }
               
        }      
       
        // Full : Trzy karty o jednakowej wartosci i para (dwie karty o jednakowej wartosci).
        // Gdy wiecej graczy posiada taki uklad wygrywa uklad z wyzszymi trzema kartami o jednakowej
        // wartosci.
        //
        // Metoda zwraca najwyzsza karte jezeli jest full, w przeciwnym wypadku zwraca 0.
        //
        public static int full(Card[] karty){
                int karta1 = karty[0].card[0];
               
                int dwojkaKarta,trojkaKarta;
                dwojkaKarta = 0;
                trojkaKarta = 0;
               
                for (int i=0; i<karty.length-1;i++){
                        karta1 = karty[i].card[0];
                        int chck1 = 0;
                        for (int j=0; j<karty.length-1;j++){
                                if(karty[j].card[0] == karty[j+1].card[0] && karty[j].card[0] == karta1){
                                        chck1++;
                                }
                        }
                        if (chck1 == 2){
                                trojkaKarta = karta1;
                        } else if (chck1 == 1){
                                dwojkaKarta = karta1;
                        } else { break; }
                }
               
                if (trojkaKarta != 0 && dwojkaKarta != 0){
                        return trojkaKarta;
                } else {
                        return 0;
                }
               
        }      
       
        // Kolor : Piec kart w jednym kolorze. Gdy wiecej graczy posiada taki uklad wygrywa
        // gracz z najwyzsza karta. W razie potrzeby do rozstrzygniecia remisu mozna wykorzystac druga,
        // trzecia, czwarta lub piata najwyzsza karte z kolei. Jesli wszystkie piec kart ma taki sam ranking
        // oglaszamy remis.
        //
        // Metoda zwraca najwyzsza karte jezeli jest kolor, w przeciwnym wypadku zwraca 0.
        //
        public static int kolor(Card[] karty){
                int chck = 0;
                for (int i=0; i<karty.length-1;i++){
                        if(karty[i].card[1] == karty[i+1].card[1]){
                                chck++;
                                //System.out.println(chck+" ");
                        }
                }      
                if (chck == 4){
                        return karty[4].card[0];
                } else { return 0; }
               
        }      
               
        // Strit : Piec kolejnych kart. Gdy wiecej graczy posiada taki uklad wygrywa uklad z
        // najwyzsza karta. Jesli najwyzsze karty maja taki sam ranking oglaszamy remis.
        //
        // Metoda zwraca najwyzsza karte jezeli jest strit, w przeciwnym wypadku zwraca 0.
        //
        public static int strit(Card[] karty){
                int chck = 0;
                for (int i=0; i<karty.length-1;i++){
                        if(karty[i].card[0]+1 == karty[i+1].card[0]){
                                chck++;
                                //System.out.println(chck+" ");
                        }
                }      
                if (chck == 4){
                        return karty[4].card[0];
                } else { return 0; }
                       
        }      
               
        // Trojka : Trzy karty o jednakowej wartosci i dwie dodatkowe. Gdy wiecej
        // graczy posiada taki uklad wygrywa najwyzsza trojka.
        //
        // Metoda zwraca najwyzsza karte jezeli jest trojka, w przeciwnym wypadku zwraca 0.
        //
        public static int trojka(Card[] karty){
                int karta1;
                for (int i=0; i<karty.length-1;i++){
                        karta1 = karty[i].card[0];
                        int chck1 = 0;
                        for (int j=0; j<karty.length-1;j++){
                                if(karty[j].card[0] == karty[j+1].card[0] && karty[j].card[0] == karta1){
                                        chck1++;
                                }
                        }
                        if (chck1 == 2) { return karta1; }
                }      
                return 0;
        }      
               
        // Dwie pary : Dwie karty o jednakowej wartosci, dwie kolejne karty o innej jednakowej wartosci i jedna karta dodatkowa.
        // Gdy wiecej graczy posiada taki uklad wygrywa najwyzsza
        // para. Jesli gracze maja te sama najwyzsza pare wygrywa posiadacz najwyzszej drugiej pary. Jesli
        // obaj gracze maja po dwie identyczne pary, wygrywa posiadacz najwyzszego "kickera" (karty
        // dodatkowej). Jesli "kickery" maja ten sam ranking oglaszamy remis.
        //
        // Metoda zwraca najwyzsza 3 elementowa tablice :
        // 1 miejsce : karta najwyzszej pary
        // 2 miejsce : karta drugiej pary
        // 3 miejsce : kicker
        //
        public static int[] dwiePary(Card[] karty){
               
                int porownanieCount = 0;
                int porownanie[] = new int [2];
                porownanie[0] = 0;
                porownanie[1] = 0;
               
                int kartyIntCount = 0;
                int kartyInt[] = new int [3];
                kartyInt[0] = 0;
                kartyInt[1] = 0;
                kartyInt[2] = 0;
               
                int bufor;
               
                for (int i=0; i<karty.length-1;i++){
                        for (int j=0; j<karty.length-1;j++){
                                if(karty[j].card[0] == karty[j+1].card[0] && karty[j].card[0] != porownanie[0] && karty[j].card[0] != porownanie[1]){
                                        //System.out.println(karty[0]+" "+karty[1]+"\n");
                                        kartyInt[kartyIntCount] = karty[j].card[0];
                                        kartyIntCount++;
                                        porownanie[porownanieCount] = karty[j].card[0];
                                        porownanieCount++;
                                        break;
                                }
                        }
                }
                for (int i=0; i<karty.length;i++){
                        if (kartyInt[0] != 0 && kartyInt[1] != 0 && karty[i].card[0] != porownanie[0] && karty[i].card[0] != porownanie[1]){
                                kartyInt[2] = karty[i].card[0];
                                break;
                        }
                }
               
                if (kartyInt[0] < kartyInt[1]){
                        bufor = kartyInt[0];
                        kartyInt[0] = kartyInt[1];
                        kartyInt[1] = bufor;
                }

                //System.out.println(karty[0]+" "+karty[1]+" "+karty[2]+"\n");
                return kartyInt;
        }      
               
        // Para : dwie karty o jednakowej wartosci i trzy karty dodatkowe o r�znych wartosciach.  
        // Gdy wiecej graczy posiada taki uklad wygrywa najwyzsza para. Jesli gracze maja te sama
        // pare, wygrywa posiadacz najwyzszej karty dodatkowej lub, w razie potrzeby, do rozstrzygniecia
        // remisu mozna wykorzystac druga albo trzecia najwyzsza karte dodatkowa. W przypadku braku
        // rozstrzygniecia oglaszamy remis.
        //
        // Metoda zwraca najwyzsza 4 elementowa tablice :
        // 1 miejsce : karta pary
        // 2 miejsce : najwieksza karta
        // 3 miejsce : druga karta
        // 4 miesjce : najmniejsza karta
        //
        public static int[] para(Card[] karty){
                //karty[i].card[0]
                int porownanieCount = 0;
                int porownanie[] = new int [3];
                porownanie[0] = 0;
                porownanie[1] = 0;
                porownanie[2] = 0;      
               
                int kartyCount = 0;
                int kartyInt[] = new int [4];
                kartyInt[0] = 0;
                kartyInt[1] = 0;
                kartyInt[2] = 0;
                kartyInt[3] = 0;
               
                int bufor;
               
                for (int j=0; j<kartyInt.length;j++){
                        //System.out.println(karty[j].card[0]+" "+karty[j+1].card[0]+"\n");
                        if(karty[j].card[0] == karty[j+1].card[0] && karty[j].card[0] != porownanie[0] && karty[j].card[0] != porownanie[1] && karty[j].card[0] != porownanie[2]){
                                //System.out.println(karty[0]+" "+karty[1]+"\n");
                                kartyInt[kartyCount] = karty[j].card[0];
                                kartyCount++;
                                porownanie[porownanieCount] = karty[j].card[0];
                                porownanieCount++;
                                break;
                        }
                }
               
                for (int i=0; i<karty.length;i++){
                        if (kartyInt[0] != 0 && karty[i].card[0] != porownanie[0] && karty[i].card[0] != porownanie[1] && karty[i].card[0] != porownanie[2]){
                                kartyInt[kartyCount] = karty[i].card[0];
                                kartyCount++;

                                if (kartyInt[3] == 0) {
                                        porownanie[porownanieCount] = karty[i].card[0];
                                        porownanieCount++;
                                }
                        }
                }
                for (int i=1; i<3;i++){
                        for (int j=1;j<3;j++){
                                if (kartyInt[j] < kartyInt [j+1]){
                                        bufor = kartyInt[j];
                                        kartyInt[j] = kartyInt[j+1];
                                        kartyInt[j+1] = bufor;
                                }
                        }
                }
               
                //System.out.println(kartyInt[0]+" "+kartyInt[1]+" "+kartyInt[2]+" "+kartyInt[3]+"\n");
                return kartyInt;
        }
       
        public static int[] cardCheck(Card[] karty)
        {

                int wynik[] = new int[6];
                Card[] cards = Wynik.sortCards(karty);
       
        boolean check = true;
        for (int i=9;i>=1;i--) {
                switch (i){
                                case 9: if (Wynik.poker(cards) != 0){
                                        wynik[0] = 9;
                                        wynik[1] = Wynik.poker(cards);
                                        check = false;
                                        //System.out.println("Poker\n");
                                        break;
                                }
                               
                        case 8: if (Wynik.kareta(cards) != 0){
                                        wynik[0] = 8;
                                        wynik[1] = Wynik.kareta(cards);
                                        check = false;
                                       // System.out.println("Kareta\n");
                                        break;
                                }
                               
                        case 7: if (Wynik.full(cards) != 0){
                                        wynik[0] = 7;
                                        wynik[1] = Wynik.full(cards);
                                        check = false;
                                       // System.out.println("Full\n");
                                        break;
                                }
                               
                        case 6: if (Wynik.kolor(cards) != 0){
                                        wynik[0] = 6;
                                        wynik[1] = Wynik.kolor(cards);
                                        check = false;
                                        //System.out.println("Kolor\n");
                                        break;
                                }
                               
                        case 5: if (Wynik.strit(cards) != 0){
                                        wynik[0] = 5;
                                        wynik[1] = Wynik.strit(cards);
                                        check = false;
                                       // System.out.println("Strit\n");
                                        break;
                                }
                               
                        case 4: if (Wynik.trojka(cards) != 0){
                                        wynik[0] = 4;
                                        wynik[1] = Wynik.trojka(cards);
                                        check = false;
                                        //System.out.println("Trojka\n");
                                        break;
                                }
                               
                        case 3: if (Wynik.dwiePary(cards)[0] != 0 && Wynik.dwiePary(cards)[1] != 0 && Wynik.dwiePary(cards)[2] != 0){
                                        wynik[0] = 3;
                                        wynik[1] = Wynik.dwiePary(cards)[0];
                                        wynik[2] = Wynik.dwiePary(cards)[1];
                                        wynik[3] = Wynik.dwiePary(cards)[2];
                                        check = false;
                                        //System.out.println("Dwie pary\n");
                                        break;
                                }
                               
                        case 2: if (Wynik.para(cards)[0] != 0 && Wynik.para(cards)[1] != 0 && Wynik.para(cards)[2] != 0 && Wynik.para(cards)[3] != 0){
                                        wynik[0] = 2;
                                        wynik[1] = Wynik.para(cards)[0];
                                       // System.out.println("Para\n");
                                        wynik[2] = Wynik.para(cards)[1];
                                       // System.out.println("Para\n");
                                        wynik[3] = Wynik.para(cards)[2];
                                       // System.out.println("Para\n");
                                        wynik[4] = Wynik.para(cards)[3];
                                       // System.out.println("Para\n");
                                        check = false;
                                        //System.out.println("Para\n");
                                        break;
                                }
                               
                        case 1: if (Wynik.poker(cards) == 0){
                                        wynik[0] = 1;
                                        for (int j=1;j<=5;j++){
                                                wynik[j] = cards[j-1].card[0];
                                        }
                                        check = false;
                                        //System.out.println("Poker\n");
                                        break;
                                }
                }
                if (check == false){
                    break;
                }
        }
       
                return wynik;
        }
       
        public static int whoWin(int[][] wyniki,int liczbaGraczy) {
                int winner = 1;
               
                int a = 0,b = 1,remis=1;
               
                while( a < 5 && b < 5) {
                        if( wyniki[a][0] < wyniki[b][0] ) {
                                winner = b + 1;
                                       
                                a = b;
                                b = b+1;
                        }
                        else if( wyniki[a][0] > wyniki[b][0] ) {
                               
                                winner = a + 1;
                                       
                                b = b+1;
                        }
                        else
                                {
                                for( int i = 1; i<5; i++ )
                                {
                                        if( wyniki[a][i] < wyniki[b][i]  ) {
                                       
                                                winner = b + 1;
                       
                                                a = b;
                                                b = b+1;                
                                                break;
                                        }
                                        else {
                                                if( wyniki[a][i] > wyniki[b][i]  ){
                                                winner = a + 1;
                       
                                                b = b+1;
                                                break;
                                                }
                                                else
                                                        {
                                                        remis = remis + 1;
                                                        if( remis == liczbaGraczy )
                                                                        return 0;
                                                        else
                                                        	b = b + 1;
                                                        }
                                        }                              
                                }
                        }
                }
               
                return winner;
        }
}
